<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
	<head>
		<title>Ramification</title>
<link href="../docs-assets/Breadcrumbs.css" rel="stylesheet" rev="stylesheet" type="text/css">
		<meta name="viewport" content="width=device-width initial-scale=1">
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
		<meta http-equiv="Content-Language" content="en-gb">

<link href="../docs-assets/Contents.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Progress.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Navigation.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Fonts.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Base.css" rel="stylesheet" rev="stylesheet" type="text/css">
<script>
function togglePopup(material_id) {
  var popup = document.getElementById(material_id);
  popup.classList.toggle("show");
}
</script>

<link href="../docs-assets/Popups.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
		
	</head>
	<body class="commentary-font">
		<nav role="navigation">
		<h1><a href="../index.html"><img src="../docs-assets/Inform.png" height=72> </a></h1>
<ul><li><a href="../index.html">home</a></li>
</ul><h2>Compiler</h2><ul>
<li><a href="../structure.html">structure</a></li>
<li><a href="../inbuildn.html">inbuild</a></li>
<li><a href="../inform7n.html">inform7</a></li>
<li><a href="../intern.html">inter</a></li>
<li><a href="../services.html">services</a></li>
<li><a href="../secrets.html">secrets</a></li>
</ul><h2>Other Tools</h2><ul>
<li><a href="../inblorbn.html">inblorb</a></li>
<li><a href="../inform6.html">inform6</a></li>
<li><a href="../inpolicyn.html">inpolicy</a></li>
</ul><h2>Resources</h2><ul>
<li><a href="../extensions.html">extensions</a></li>
<li><a href="../kits.html">kits</a></li>
</ul><h2>Repository</h2><ul>
<li><a href="https://github.com/ganelson/inform"><img src="../docs-assets/github.png" height=0> github</a></li>
</ul><h2>Related Projects</h2><ul>
<li><a href="https://github.com/ganelson/inweb"><img src="../docs-assets/github.png" height=0> inweb</a></li>
<li><a href="https://github.com/ganelson/intest"><img src="../docs-assets/github.png" height=0> intest</a></li>
</ul>
		</nav>
		<main role="main">
		<!-- Weave of 'Ramification' generated by inweb -->
<div class="breadcrumbs">
    <ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../intern.html">Inter Modules</a></li><li><a href="index.html">building</a></li><li><a href="index.html#2">Chapter 2: Blueprints</a></li><li><b>Ramification</b></li></ul></div>
<p class="purpose">Turning textual code written in Inform 6 syntax into an inter schema.</p>

<ul class="toc"><li><a href="2-rmf.html#SP1">&#167;1. Introduction</a></li><li><a href="2-rmf.html#SP3">&#167;3. The implied braces ramification</a></li><li><a href="2-rmf.html#SP4">&#167;4. The unbrace schema ramification</a></li><li><a href="2-rmf.html#SP5">&#167;5. The divide schema ramification</a></li><li><a href="2-rmf.html#SP6">&#167;6. The undivide schema ramification</a></li><li><a href="2-rmf.html#SP7">&#167;7. The resolve halfopen blocks ramification</a></li><li><a href="2-rmf.html#SP8">&#167;8. The break early bracings ramification</a></li><li><a href="2-rmf.html#SP9">&#167;9. The strip leading white space ramification</a></li><li><a href="2-rmf.html#SP10">&#167;10. The split switches into cases ramification</a></li><li><a href="2-rmf.html#SP12">&#167;12. The split print statements ramification</a></li><li><a href="2-rmf.html#SP13">&#167;13. The identify constructs ramification</a></li><li><a href="2-rmf.html#SP14">&#167;14. The break for statements ramification</a></li><li><a href="2-rmf.html#SP15">&#167;15. The add missing bodies ramification</a></li><li><a href="2-rmf.html#SP16">&#167;16. The remove empty expressions ramification</a></li><li><a href="2-rmf.html#SP17">&#167;17. The outer subexpressions ramification</a></li><li><a href="2-rmf.html#SP18">&#167;18. The top level commas ramification</a></li><li><a href="2-rmf.html#SP19">&#167;19. The multiple case values ramification</a></li><li><a href="2-rmf.html#SP20">&#167;20. The strip all white space ramification</a></li><li><a href="2-rmf.html#SP21">&#167;21. The debracket ramification</a></li><li><a href="2-rmf.html#SP25">&#167;25. The implied return values ramification</a></li><li><a href="2-rmf.html#SP26">&#167;26. The message calls ramification</a></li><li><a href="2-rmf.html#SP27">&#167;27. The sanity check ramification</a></li></ul><hr class="tocbar">

<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Introduction.</b>Once <a href="2-tkn.html" class="internal">Tokenisation</a> has been done, we have an inter schema which is not
really a tree, but a linked list in all but name &mdash;
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
<span class="plain-syntax">        ...</span>
</pre>
<p class="commentary">So, there is no internal structure yet. "Ramification" performs a series of
transformations on this tree, gradually shaking out the (sometimes ambiguous)
syntactic markers such as <span class="extract"><span class="extract-syntax">COMMA_ISTT</span></span> and replacing them with semantically
clear subtrees.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::go</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Ramification::go</span></span>:<br/>Parsing Inter Schemas - <a href="2-pis.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sch</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP3" class="function-link"><span class="function-syntax">Ramification::implied_braces</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP4" class="function-link"><span class="function-syntax">Ramification::unbrace_schema</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP5" class="function-link"><span class="function-syntax">Ramification::divide_schema</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP6" class="function-link"><span class="function-syntax">Ramification::undivide_schema</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP7" class="function-link"><span class="function-syntax">Ramification::resolve_halfopen_blocks</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP8" class="function-link"><span class="function-syntax">Ramification::break_early_bracings</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP9" class="function-link"><span class="function-syntax">Ramification::strip_leading_white_space</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP10" class="function-link"><span class="function-syntax">Ramification::split_switches_into_cases</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP9" class="function-link"><span class="function-syntax">Ramification::strip_leading_white_space</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP12" class="function-link"><span class="function-syntax">Ramification::split_print_statements</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP13" class="function-link"><span class="function-syntax">Ramification::identify_constructs</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP14" class="function-link"><span class="function-syntax">Ramification::break_for_statements</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP15" class="function-link"><span class="function-syntax">Ramification::add_missing_bodies</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP16" class="function-link"><span class="function-syntax">Ramification::remove_empties</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP17" class="function-link"><span class="function-syntax">Ramification::outer_subexpressions</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP18" class="function-link"><span class="function-syntax">Ramification::top_level_commas</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP19" class="function-link"><span class="function-syntax">Ramification::multiple_case_values</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP20" class="function-link"><span class="function-syntax">Ramification::strip_all_white_space</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP21" class="function-link"><span class="function-syntax">Ramification::debracket</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP25" class="function-link"><span class="function-syntax">Ramification::implied_return_values</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP26" class="function-link"><span class="function-syntax">Ramification::message_calls</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><a href="2-rmf.html#SP27" class="function-link"><span class="function-syntax">Ramification::sanity_check</span></a><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>Each transformation will be applied until it returns <span class="extract"><span class="extract-syntax">FALSE</span></span> to say that
it could see nothing to do, or <span class="extract"><span class="extract-syntax">NOT_APPLICABLE</span></span> to say that it did but
that it doesn't want to be called again. Some transformations make use
of temporary markers attached to nodes or tokens in the tree, so we clear
these out at the start of each iteration.
</p>

<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="identifier-syntax">REPEATEDLY_APPLY</span><span class="plain-syntax">(</span><span class="identifier-syntax">X</span><span class="plain-syntax">)</span>
<span class="plain-syntax">    {</span>
<span class="plain-syntax">        </span><a href="2-rmf.html#SP2" class="function-link"><span class="function-syntax">Ramification::unmark</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_tree</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">sch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parsing_errors</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">X</span><span class="plain-syntax">(</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">sch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_tree</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">rv</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">SCHEMA_COMPILATION_DETAILS</span><span class="plain-syntax">, </span><span class="string-syntax">"After round of "</span><span class="plain-syntax"> #</span><span class="identifier-syntax">X</span><span class="plain-syntax"> </span><span class="string-syntax">":\n$1\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">sch</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">rv</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NOT_APPLICABLE</span><span class="plain-syntax">) </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::unmark</span><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">preinsert</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">postinsert</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><a href="2-rmf.html#SP2" class="function-link"><span class="function-syntax">Ramification::unmark</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. The implied braces ramification.</b>In common with most C-like languages, though unlike Perl, Inform 6 makes braces
optional around code blocks which contain only a single statement. Thus:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">x</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"x is 1.^"</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary">is understood as if it were
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">x</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) { </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"x is 1.^"</span><span class="plain-syntax">; }</span>
</pre>
<p class="commentary">But we will find future ramifications much easier to code up if braces are
always used. So this one looks for cases where braces have been omitted,
and inserts them around the single statements in question.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::implied_braces</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Ramification::implied_braces</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">at</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">at</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">IF_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHILE_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">FOR_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">SWITCH_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">OBJECTLOOP_I6RW</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Make pre and post markers from here</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">ELSE_I6RW</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Make pre and post markers from here</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><span class="identifier-syntax">rounds</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">changed</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; </span><span class="identifier-syntax">rounds</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">at</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prev</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">preinsert</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">preinsert</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">open_b</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"{"</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">line_offset</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP14" class="function-link"><span class="function-syntax">InterSchemas::add_token_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">open_b</span><span class="plain-syntax">, </span><span class="identifier-syntax">prev</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">postinsert</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">postinsert</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">close_b</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CLOSE_BRACE_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"}"</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">line_offset</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP14" class="function-link"><span class="function-syntax">InterSchemas::add_token_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">close_b</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">rounds</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">NOT_APPLICABLE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3_1" class="paragraph-anchor"></a><b>&#167;3.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make pre and post markers from here</span><span class="named-paragraph-number">3.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">preinsert</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">found_if</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">brl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">posted</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">upped</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">last_n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">) { </span><span class="identifier-syntax">brl</span><span class="plain-syntax">++; </span><span class="identifier-syntax">upped</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_BRACE_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">brl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">IF_I6RW</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">found_if</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">brl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DIVIDER_ISTT</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                ((</span><span class="identifier-syntax">upped</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_BRACE_ISTT</span><span class="plain-syntax">)))) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">m</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">found_if</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">m</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                (</span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> != </span><span class="constant-syntax">ELSE_I6RW</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">postinsert</span><span class="plain-syntax">++; </span><span class="identifier-syntax">posted</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">last_n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">posted</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">last_n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">postinsert</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP3">&#167;3</a> (twice).</li></ul>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. The unbrace schema ramification.</b>We now remove braces used to delimit code blocks and replace them with <span class="extract"><span class="extract-syntax">CODE_ISNT</span></span>
subtrees. So for example
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="constant-syntax">OPEN_BRACE_ISTT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="constant-syntax">CLOSE_BRACE_ISTT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
</pre>
<p class="commentary">becomes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">    </span><span class="constant-syntax">CODE_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
</pre>
<p class="commentary">In this way, all matching pairs of <span class="extract"><span class="extract-syntax">OPEN_BRACE_ISTT</span></span> and <span class="extract"><span class="extract-syntax">CLOSE_BRACE_ISTT</span></span> tokens
are removed.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::unbrace_schema</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">Ramification::unbrace_schema</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prev</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">code_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">CODE_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) { </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">; }</span>

<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">pn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">brl</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_BRACE_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_BRACE_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">brl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">brl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pn</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">pn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">pn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">resumed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">resumed</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">resumed</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">resumed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">resumed</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">resumed</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                            </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">resumed</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP4" class="function-link"><span class="function-syntax">Ramification::unbrace_schema</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. The divide schema ramification.</b>A <span class="extract"><span class="extract-syntax">DIVIDER_ISTT</span></span> token represents a semicolon used to divide I6 statements.
We want to represent them, however, by independent subtrees. So:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
</pre>
<p class="commentary">becomes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
</pre>
<p class="commentary">After this stage, therefore, each statement occupies its own <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span>.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::divide_schema</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Ramification::divide_schema</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DIVIDER_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP5" class="function-link"><span class="function-syntax">Ramification::divide_schema</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. The undivide schema ramification.</b>The expression nodes for statements now tend to end with <span class="extract"><span class="extract-syntax">DIVIDER_ISTT</span></span> tokens
which no longer have any useful meaning. We remove them. For example:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DIVIDER_ISTT</span>
</pre>
<p class="commentary">becomes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T4</span>
</pre>
<p class="commentary">After this, then, there are no further <span class="extract"><span class="extract-syntax">DIVIDER_ISTT</span></span> tokens in the tree.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::undivide_schema</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Ramification::undivide_schema</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DIVIDER_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DIVIDER_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP6" class="function-link"><span class="function-syntax">Ramification::undivide_schema</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">rv</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. The resolve halfopen blocks ramification.</b>At this point, all matching pairs of open and close braces have been removed.
But that doesn't quite solve the problem of code blocks, because an inline
phrase in Inform 7 can use the notations <span class="extract"><span class="extract-syntax">{-open-brace}</span></span> or <span class="extract"><span class="extract-syntax">{-close-brace}</span></span>
to indicate that a code block must be opened or closed, in a way which does
not pair up.
</p>

<p class="commentary">There is clearly no way for a tree structure to encode a half-open subtree,
so the schema itself has to have a special annotation made in this case, which
is done by calling <a href="2-is.html#SP5" class="internal">InterSchemas::mark_unclosed</a> or <a href="2-is.html#SP6" class="internal">InterSchemas::mark_unopened</a>.
It is inconvenient to delete the brace command node (we might end up with an
empty <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> list), so instead we convert it to a harmless piece
of white space.
</p>

<p class="commentary">At the end of this process, then, all code blocks are correctly handled, and
all statements are held as single <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> nodes. So the coarse
structure of the code is correctly handled &mdash; we have a clear tree structure
of statements (or expressions), hierarchically arranged in code blocks.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::resolve_halfopen_blocks</span><button class="popup" onclick="togglePopup('usagePopup6')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup6">Usage of <span class="code-font"><span class="function-syntax">Ramification::resolve_halfopen_blocks</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">INLINE_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">inline_command</span><span class="plain-syntax"> == </span><span class="constant-syntax">open_brace_ISINC</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP5" class="function-link"><span class="function-syntax">InterSchemas::mark_unclosed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">" "</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">INLINE_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">inline_command</span><span class="plain-syntax"> == </span><span class="constant-syntax">close_brace_ISINC</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP6" class="function-link"><span class="function-syntax">InterSchemas::mark_unopened</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">" "</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP7" class="function-link"><span class="function-syntax">Ramification::resolve_halfopen_blocks</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. The break early bracings ramification.</b>If an expression list begins with one or more braced commands, perhaps with some
white space, and then continues with some honest I6 material, we divide the
early commands off from the subsequent matter. Thus:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">INLINE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">INLINE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
</pre>
<p class="commentary">becomes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">INLINE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">INLINE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T1</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T2</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">T3</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::break_early_bracings</span><button class="popup" onclick="togglePopup('usagePopup7')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup7">Usage of <span class="code-font"><span class="function-syntax">Ramification::break_early_bracings</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP8" class="function-link"><span class="function-syntax">Ramification::permitted_early</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">m</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP8" class="function-link"><span class="function-syntax">Ramification::break_early_bracings</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::permitted_early</span><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">INLINE_ISTT</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. The strip leading white space ramification.</b>If an expression begins with white space, remove it. (This makes coding subsequent
ramifications easier &mdash; because we can assume the first token is substantive.)
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::strip_leading_white_space</span><button class="popup" onclick="togglePopup('usagePopup8')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup8">Usage of <span class="code-font"><span class="function-syntax">Ramification::strip_leading_white_space</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP9" class="function-link"><span class="function-syntax">Ramification::strip_leading_white_space</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. The split switches into cases ramification.</b>Unlike most C-like languages, Inform 6 does not have a <span class="extract"><span class="extract-syntax">case</span></span> reserved word to
introduce cases in a <span class="extract"><span class="extract-syntax">switch</span></span> statement. For example:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">x</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">3</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"Do one thing."</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="constant-syntax">4</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"Do a different thing."</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">default</span><span class="plain-syntax">: </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"Otherwise, do this other thing."</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<p class="commentary">Here, the colons and the reserved word <span class="extract"><span class="extract-syntax">default</span></span> are the important syntactic markers.
We break this up as three code blocks:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> </span><span class="string-syntax">"case"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">1</span>
<span class="plain-syntax">            </span><span class="constant-syntax">COMMA_ISTT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">2</span>
<span class="plain-syntax">            </span><span class="constant-syntax">COMMA_ISTT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">3</span>
<span class="plain-syntax">        </span><span class="constant-syntax">CODE_ISNT</span>
<span class="plain-syntax">            ...</span>
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> </span><span class="string-syntax">"case"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">4</span>
<span class="plain-syntax">        </span><span class="constant-syntax">CODE_ISNT</span>
<span class="plain-syntax">            ...</span>
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> </span><span class="string-syntax">"default"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">CODE_ISNT</span>
<span class="plain-syntax">            ...</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::split_switches_into_cases</span><button class="popup" onclick="togglePopup('usagePopup9')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup9">Usage of <span class="code-font"><span class="function-syntax">Ramification::split_switches_into_cases</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COLON_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">original_child</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">defaulter</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                        (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                        (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">DEFAULT_I6RW</span><span class="plain-syntax">)) </span><span class="identifier-syntax">defaulter</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sw_val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sw_code</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">defaulter</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax"> = </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">CODE_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_val</span><span class="plain-syntax"> = </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax"> = </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">CODE_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">switch_begins</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">switch_ends</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">pn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                            (</span><span class="identifier-syntax">pn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                            (</span><span class="identifier-syntax">pn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">SWITCH_I6RW</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                            </span><span class="identifier-syntax">switch_begins</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pn2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pn2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pn2</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) { </span><span class="identifier-syntax">switch_ends</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">                                </span><span class="identifier-syntax">pn2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">pn2</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                            }</span>
<span class="plain-syntax">                            </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        }</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">pn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">pn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">switch_ends</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><a href="2-is.html#SP5" class="function-link"><span class="function-syntax">InterSchemas::mark_unclosed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">switch_begins</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><a href="2-is.html#SP7" class="function-link"><span class="function-syntax">InterSchemas::mark_case_closed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">) </span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">defaulter</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">DEFAULT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">else</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">CASE_BIP</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sw_val</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">);</span>

<span class="plain-syntax">                    </span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">original_child</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">attach</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code_exp</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">at</span><span class="plain-syntax">) &amp;&amp; (</span><a href="2-rmf.html#SP11" class="function-link"><span class="function-syntax">Ramification::casey</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">at</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">next_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">at</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sw_code</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">attach</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">at</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">attach</span><span class="plain-syntax"> = </span><span class="identifier-syntax">at</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">next_at</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">next_at</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>

<span class="plain-syntax">                    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP10" class="function-link"><span class="function-syntax">Ramification::split_switches_into_cases</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. </b></p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::casey</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">Ramification::casey</span></span>:<br/><a href="2-rmf.html#SP10">&#167;10</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COLON_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. The split print statements ramification.</b>Inform 6 supports composite print statements, like so:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">print_ret</span><span class="plain-syntax"> </span><span class="string-syntax">"X is "</span><span class="plain-syntax">, </span><span class="identifier-syntax">x</span><span class="plain-syntax">, </span><span class="string-syntax">"."</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary">This example currently looks like:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"print_ret"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"X is "</span>
<span class="plain-syntax">        </span><span class="constant-syntax">COMMA_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"x"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">COMMA_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"."</span>
</pre>
<p class="commentary">We break this up as three individual prints:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"print"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"X is "</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"print"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"x"</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"print_ret"</span>
<span class="plain-syntax">        </span><span class="constant-syntax">WHITE_SPACE_ISTT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax"> </span><span class="string-syntax">"."</span>
</pre>
<p class="commentary">Note that, for obvious reasons, in the <span class="extract"><span class="extract-syntax">print_ret</span></span> case only the third of the
prints should perform a return.
</p>

<p class="commentary">The point of this stage is to get rid of one source of <span class="extract"><span class="extract-syntax">COMMA_ISTT</span></span> tokens;
commas can mean a number of different things in Inform 6 syntax and it makes
our work simpler to take one of those meanings out of the picture.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::split_print_statements</span><button class="popup" onclick="togglePopup('usagePopup11')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup11">Usage of <span class="code-font"><span class="function-syntax">Ramification::split_print_statements</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                &amp;&amp; ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">PRINT_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">PRINTRET_I6RW</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COMMA_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">RESERVED_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINT_I6RW</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"print"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">reserved_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">PRINT_I6RW</span><span class="plain-syntax">) </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"print"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"print_ret"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                            </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP12" class="function-link"><span class="function-syntax">Ramification::split_print_statements</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>&#167;13. The identify constructs ramification.</b>At this point each individual expression or statement is represented by the
tokens under an <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> node. It's legal to give an expression as
a statement in Inform 6, i.e., in void context, just as it is in C. But we
can tell the difference because statements are introduced by reserved words
such as <span class="extract"><span class="extract-syntax">while</span></span>; and this is where we do that.
</p>

<p class="commentary">Here <span class="extract"><span class="extract-syntax">par</span></span> is the parent node, and <span class="extract"><span class="extract-syntax">cons</span></span> the construct, presumably an <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span>.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::identify_constructs</span><button class="popup" onclick="togglePopup('usagePopup12')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup12">Usage of <span class="code-font"><span class="function-syntax">Ramification::identify_constructs</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cons</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">cons</span><span class="plain-syntax">; </span><span class="identifier-syntax">cons</span><span class="plain-syntax">=</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">first</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = -1;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">dangle_text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, *</span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RESERVED_ISTT:</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1" class="named-paragraph-link"><span class="named-paragraph">If this expression opens with a reserved word, it may be a statement</span><span class="named-paragraph-number">13.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DIRECTIVE_ISTT:</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_2" class="named-paragraph-link"><span class="named-paragraph">If this expression opens with a directive keyword, it is a directive</span><span class="named-paragraph-number">13.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OPCODE_ISTT:</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_3" class="named-paragraph-link"><span class="named-paragraph">If this expression opens with an opcode keyword, it is an assembly line</span><span class="named-paragraph-number">13.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>

<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">which_statement</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_4" class="named-paragraph-link"><span class="named-paragraph">Make this a STATEMENT_ISNT node</span><span class="named-paragraph-number">13.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">ASSEMBLY_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">DIRECTIVE_ISNT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP13" class="function-link"><span class="function-syntax">Ramification::identify_constructs</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">, </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP13_1" class="paragraph-anchor"></a><b>&#167;13.1. </b>To have the node converted from <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> to <span class="extract"><span class="extract-syntax">STATEMENT_ISNT</span></span>, we must
set <span class="extract"><span class="extract-syntax">which_statement</span></span> to the BIP of the Inter primitive which will implement it.
If we set <span class="extract"><span class="extract-syntax">dangle_number</span></span> to some non-negative value, then that will be added
as an argument. Thus:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">rfalse</span>
</pre>
<p class="commentary">becomes:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> - </span><span class="constant-syntax">RETURN_BIP</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="constant-syntax">0</span>
</pre>
<p class="commentary">The <span class="extract"><span class="extract-syntax">0</span></span> is an invention &mdash; in that it never occurs in the original text &mdash; and
its expression dangles beneath the <span class="extract"><span class="extract-syntax">STATEMENT_ISNT</span></span> node; and similarly for
a <span class="extract"><span class="extract-syntax">dangle_text</span></span>, of course.
</p>

<p class="commentary">The set of Inform 6 statements is a mixed bag, to put it mildly, and some have
oddball syntaxes. Here goes:
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If this expression opens with a reserved word, it may be a statement</span><span class="named-paragraph-number">13.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::opening_reserved_word</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">BREAK_I6RW:</span><span class="plain-syntax">      </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">BREAK_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CONTINUE_I6RW:</span><span class="plain-syntax">   </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">CONTINUE_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DO_I6RW:</span><span class="plain-syntax">         </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_1" class="named-paragraph-link"><span class="named-paragraph">This is a do statement</span><span class="named-paragraph-number">13.1.1</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">FONT_I6RW:</span><span class="plain-syntax">       </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_2" class="named-paragraph-link"><span class="named-paragraph">This is a font statement</span><span class="named-paragraph-number">13.1.2</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">FOR_I6RW:</span><span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">FOR_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">GIVE_I6RW:</span><span class="plain-syntax">       </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_3" class="named-paragraph-link"><span class="named-paragraph">This is a give statement</span><span class="named-paragraph-number">13.1.3</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_I6RW:</span><span class="plain-syntax">         </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_4" class="named-paragraph-link"><span class="named-paragraph">This is an if statement</span><span class="named-paragraph-number">13.1.4</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">INVERSION_I6RW:</span><span class="plain-syntax">  </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINT_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"v6"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">JUMP_I6RW:</span><span class="plain-syntax">       </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">JUMP_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">MOVE_I6RW:</span><span class="plain-syntax">       </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_5" class="named-paragraph-link"><span class="named-paragraph">This is a move statement</span><span class="named-paragraph-number">13.1.5</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEWLINE_I6RW:</span><span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINT_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"\n"</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OBJECTLOOP_I6RW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">OBJECTLOOP_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINT_I6RW:</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTRET_I6RW:</span><span class="plain-syntax">   </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_7" class="named-paragraph-link"><span class="named-paragraph">This is a print statement</span><span class="named-paragraph-number">13.1.7</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">QUIT_I6RW:</span><span class="plain-syntax">       </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">QUIT_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">READ_I6RW:</span><span class="plain-syntax">       </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_8" class="named-paragraph-link"><span class="named-paragraph">This is a read statement</span><span class="named-paragraph-number">13.1.8</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">REMOVE_I6RW:</span><span class="plain-syntax">     </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">REMOVE_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RESTORE_I6RW:</span><span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">RESTORE_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RETURN_I6RW:</span><span class="plain-syntax">     </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">RETURN_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RFALSE_I6RW:</span><span class="plain-syntax">     </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">RETURN_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RTRUE_I6RW:</span><span class="plain-syntax">      </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">RETURN_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">SPACES_I6RW:</span><span class="plain-syntax">     </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">SPACES_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STYLE_I6RW:</span><span class="plain-syntax">      </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_6" class="named-paragraph-link"><span class="named-paragraph">This is a style statement</span><span class="named-paragraph-number">13.1.6</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">SWITCH_I6RW:</span><span class="plain-syntax">     </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">SWITCH_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">WHILE_I6RW:</span><span class="plain-syntax">      </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">WHILE_BIP</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13">&#167;13</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_1" class="paragraph-anchor"></a><b>&#167;13.1.1. </b>The Inform 6 syntax <span class="extract"><span class="extract-syntax">do ...; until ...;</span></span> currently appears as two consecutive
nodes, which we want to fold into just one:
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a do statement</span><span class="named-paragraph-number">13.1.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">until_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::opening_reserved_word</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">until_node</span><span class="plain-syntax">) == </span><span class="constant-syntax">UNTIL_I6RW</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">DO_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">until_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">until_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"do without until"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_2" class="paragraph-anchor"></a><b>&#167;13.1.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a font statement</span><span class="named-paragraph-number">13.1.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">FONT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"on"</span><span class="plain-syntax">))) </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"off"</span><span class="plain-syntax">))) </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">, </span><span class="string-syntax">"expected 'on' or 'off' after 'font', not '%S'"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">, </span><span class="identifier-syntax">msg</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_3" class="paragraph-anchor"></a><b>&#167;13.1.3. </b>Here <span class="extract"><span class="extract-syntax">give O P</span></span> sets attribute <span class="extract"><span class="extract-syntax">P</span></span> for object <span class="extract"><span class="extract-syntax">O</span></span>, and <span class="extract"><span class="extract-syntax">give O ~P</span></span> takes
it away again; this looks like a use of the bitwise-not operator but is not.
</p>

<p class="commentary">There is actually no statement node corresponding to <span class="extract"><span class="extract-syntax">STORE_BIP</span></span>; that's
just a device to be picked up below.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a give statement</span><span class="named-paragraph-number">13.1.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">operand1</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPERATOR_ISTT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">operation_primitive</span><span class="plain-syntax"> == </span><span class="constant-syntax">BITWISENOT_BIP</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">STORE_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">STORE_BIP</span><span class="plain-syntax">; </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_4" class="paragraph-anchor"></a><b>&#167;13.1.4. </b>Here Inform 6 might use <span class="extract"><span class="extract-syntax">if ...; else ...;</span></span>, or might not have the <span class="extract"><span class="extract-syntax">else</span></span>
clause at all. We split these possibilities into two different statement nodes.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is an if statement</span><span class="named-paragraph-number">13.1.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">IF_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">else_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::opening_reserved_word</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">else_node</span><span class="plain-syntax">) == </span><span class="constant-syntax">ELSE_I6RW</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">else_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">else_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">operand2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">IFELSE_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">else_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">else_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_5" class="paragraph-anchor"></a><b>&#167;13.1.5. </b>The syntax here is <span class="extract"><span class="extract-syntax">move ... to ...</span></span>, where the keyword <span class="extract"><span class="extract-syntax">to</span></span> is compulsory.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a move statement</span><span class="named-paragraph-number">13.1.5</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">operand1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">to</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">to</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"to"</span><span class="plain-syntax">)) </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">to</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">to</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"move without to"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">to</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">to</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">to</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">" "</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">to</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">operand1</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">operand2</span><span class="plain-syntax">)) </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">MOVE_BIP</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_6" class="paragraph-anchor"></a><b>&#167;13.1.6. </b>Inform 6 in fact only supports <span class="extract"><span class="extract-syntax">style</span></span> followed by one of these four keywords,
but we are extending it to allow for more interesting stylistics when away from
the traditional IF virtual machines. So we will allow <span class="extract"><span class="extract-syntax">style X</span></span>, where <span class="extract"><span class="extract-syntax">X</span></span> is
anything else, too.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a style statement</span><span class="named-paragraph-number">13.1.6</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">STYLE_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"roman"</span><span class="plain-syntax">))     </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"bold"</span><span class="plain-syntax">))      </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"underline"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"reverse"</span><span class="plain-syntax">))   </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> = </span><span class="constant-syntax">3</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_7" class="paragraph-anchor"></a><b>&#167;13.1.7. </b>Note that composite print statements have already been broken up, so that
we only have three possibilities:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="identifier-syntax">some_number</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"Some text"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">some_rule</span><span class="plain-syntax">) </span><span class="identifier-syntax">some_value</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary">(or the same but with <span class="extract"><span class="extract-syntax">print_ret</span></span> instead of <span class="extract"><span class="extract-syntax">print</span></span>). The first two cases
are straightforward and become usages of <span class="extract"><span class="extract-syntax">PRINTNUMBER_BIP</span></span> or <span class="extract"><span class="extract-syntax">PRINT_BIP</span></span>
respectively.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a print statement</span><span class="named-paragraph-number">13.1.7</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">uses_printing_rule_in_brackets_notation</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINTNUMBER_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">uses_printing_rule_in_brackets_notation</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_7_1" class="named-paragraph-link"><span class="named-paragraph">This uses the printing-rule-in-brackets notation</span><span class="named-paragraph-number">13.1.7.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">uses_printing_rule_in_brackets_notation</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::opening_reserved_word</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">) == </span><span class="constant-syntax">PRINTRET_I6RW</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_7_2" class="named-paragraph-link"><span class="named-paragraph">Add printing a newline and returning true to the schema</span><span class="named-paragraph-number">13.1.7.2</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_7_1" class="paragraph-anchor"></a><b>&#167;13.1.7.1. </b>The printing rule given in brackets can be one of 13 special cases, or else
can be the name of some function. All but 4 of these special cases will be
turned into function calls too, leaving:
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This uses the printing-rule-in-brackets notation</span><span class="named-paragraph-number">13.1.7.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"address"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINTDWORD_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"char"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINTCHAR_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"string"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINTSTRING_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"object"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINTOBJ_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_1_7_1_1" class="named-paragraph-link"><span class="named-paragraph">Convert this to a function call</span><span class="named-paragraph-number">13.1.7.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1_7">&#167;13.1.7</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_7_1_1" class="paragraph-anchor"></a><b>&#167;13.1.7.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Convert this to a function call</span><span class="named-paragraph-number">13.1.7.1.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"the"</span><span class="plain-syntax">))                         </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"DefArt"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"The"</span><span class="plain-syntax">))                         </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"CDefArt"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"a"</span><span class="plain-syntax">)) || (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"an"</span><span class="plain-syntax">))) </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"IndefArt"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"A"</span><span class="plain-syntax">)) || (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"An"</span><span class="plain-syntax">))) </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"CIndefArt"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"number"</span><span class="plain-syntax">))                      </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"LanguageNumber"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"name"</span><span class="plain-syntax">))                        </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"PrintShortName"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"property"</span><span class="plain-syntax">))                    </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"DebugProperty"</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">fn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">open_b</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"("</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">line_offset</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP14" class="function-link"><span class="function-syntax">InterSchemas::add_token_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">open_b</span><span class="plain-syntax">, </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">open_b</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">open_b</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)) </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">close_b</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">")"</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="identifier-syntax">printing_rule</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">line_offset</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP14" class="function-link"><span class="function-syntax">InterSchemas::add_token_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">close_b</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1_7_1">&#167;13.1.7.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_7_2" class="paragraph-anchor"></a><b>&#167;13.1.7.2. </b>This is the difference between a <span class="extract"><span class="extract-syntax">print</span></span> and a <span class="extract"><span class="extract-syntax">print_ret</span></span>: the latter
gets two additional statement nodes added after it, one to print a newline
character, and one to return <span class="extract"><span class="extract-syntax">true</span></span>.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Add printing a newline and returning true to the schema</span><span class="named-paragraph-number">13.1.7.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">save_next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">PRINT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP14" class="function-link"><span class="function-syntax">InterSchemas::add_token_to_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">,</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"\n"</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">));</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">RETURN_BIP</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">save_next</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1_7">&#167;13.1.7</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_1_8" class="paragraph-anchor"></a><b>&#167;13.1.8. </b><span class="extract"><span class="extract-syntax">read</span></span> is an awkward sod of a statement because of the way it is handled
differently on 16-bit vs 32-bit platforms. <span class="extract"><span class="extract-syntax">READ_XBIP</span></span> is a sort of placeholder
for worrying about this only later; it means that this schema does not need
to know about the difference.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This is a read statement</span><span class="named-paragraph-number">13.1.8</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand2</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">operand1</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand1</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">operand2</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">operand1</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">operand2</span><span class="plain-syntax">)) </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">READ_XBIP</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_1">&#167;13.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_2" class="paragraph-anchor"></a><b>&#167;13.2. </b>Directives are much easier. For example,
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        #</span><span class="identifier-syntax">ifdef</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">DEBUG</span>
</pre>
<p class="commentary">becomes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">DIRECTIVE_ISNT</span><span class="plain-syntax"> = #</span><span class="identifier-syntax">IFDEF</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">DEBUG</span>
</pre>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If this expression opens with a directive keyword, it is a directive</span><span class="named-paragraph-number">13.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">DIRECTIVE_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">dir_clarifier</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::opening_directive_word</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">first</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13">&#167;13</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_3" class="paragraph-anchor"></a><b>&#167;13.3. </b>Assembly language is basically simple, but with a couple of wrinkles:
</p>

<ul class="items"><li>(a) <span class="extract"><span class="extract-syntax">@push</span></span> and <span class="extract"><span class="extract-syntax">@pull</span></span> are converted to Inter statement nodes;
</li><li>(b) we must be careful about unary minus signs, in <span class="extract"><span class="extract-syntax">@hypothetical -1</span></span>,
which would be tokenised as <span class="extract"><span class="extract-syntax">@hypothetical - 1</span></span>;
</li><li>(c) the special notations <span class="extract"><span class="extract-syntax">sp</span></span> (stack pointer), <span class="extract"><span class="extract-syntax">-&gt;</span></span> and <span class="extract"><span class="extract-syntax">?labelname</span></span> need
to be recognised for what they are.
</li></ul>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If this expression opens with an opcode keyword, it is an assembly line</span><span class="named-paragraph-number">13.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">f</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">         </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">f</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@push"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PUSH_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">f</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@pull"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> = </span><span class="constant-syntax">PULL_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">ASSEMBLY_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">f</span><span class="plain-syntax">, *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">l</span><span class="plain-syntax">?(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">):</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">=</span><span class="identifier-syntax">n</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">=</span><span class="identifier-syntax">n</span><span class="plain-syntax">?(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">):</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"("</span><span class="plain-syntax">))) </span><span class="reserved-syntax">continue</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">")"</span><span class="plain-syntax">))) </span><span class="reserved-syntax">continue</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">l</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">operation_primitive</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">operation_primitive</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"-"</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::new</span><span class="plain-syntax">();</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="string-syntax">"-%S"</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"-&gt;"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">ASM_ARROW_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"sp"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">ASM_SP_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"?"</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">ASM_LABEL_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"~"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">ASM_NEGATED_LABEL_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prev_node</span><span class="plain-syntax">) </span><span class="identifier-syntax">prev_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">prev_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13">&#167;13</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_4" class="paragraph-anchor"></a><b>&#167;13.4. </b>Finally! In the case where we do want to make a <span class="extract"><span class="extract-syntax">STATEMENT_ISNT</span></span> node &mdash;
either through recognising an I6 statement word like <span class="extract"><span class="extract-syntax">while</span></span>, or one of the
assembly instructions <span class="extract"><span class="extract-syntax">@push</span></span> or <span class="extract"><span class="extract-syntax">@pull</span></span> &mdash; we do the following.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make this a STATEMENT_ISNT node</span><span class="named-paragraph-number">13.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="identifier-syntax">which_statement</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">first_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_4_1" class="named-paragraph-link"><span class="named-paragraph">Make the first child</span><span class="named-paragraph-number">13.4.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> != </span><span class="constant-syntax">STORE_BIP</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_4_2" class="named-paragraph-link"><span class="named-paragraph">Dangle the number or text</span><span class="named-paragraph-number">13.4.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_4_3" class="named-paragraph-link"><span class="named-paragraph">Make the second child</span><span class="named-paragraph-number">13.4.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> == </span><span class="constant-syntax">STORE_BIP</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP13_4_4" class="named-paragraph-link"><span class="named-paragraph">The special case of giving an attribute</span><span class="named-paragraph-number">13.4.4</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13">&#167;13</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_4_1" class="paragraph-anchor"></a><b>&#167;13.4.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the first child</span><span class="named-paragraph-number">13.4.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">first_child</span><span class="plain-syntax"> = </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">first</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">operand1</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::second_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">operand1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">first_child</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_4">&#167;13.4</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_4_2" class="paragraph-anchor"></a><b>&#167;13.4.2. </b>Ordinarily, <span class="extract"><span class="extract-syntax">operand1</span></span> provides the content for the first child expression,
but in the case of a dangling number or text, we use that instead. (Note that
they cannot both apply.)
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Dangle the number or text</span><span class="named-paragraph-number">13.4.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">T</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::new</span><span class="plain-syntax">();</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="string-syntax">"%d"</span><span class="plain-syntax">, </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">dangle_text</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">DQUOTED_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">dangle_text</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_4">&#167;13.4</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_4_3" class="paragraph-anchor"></a><b>&#167;13.4.3. </b>There is often no second child. But when there is:
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the second child</span><span class="named-paragraph-number">13.4.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">operand2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">second_child</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">first</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">which_statement</span><span class="plain-syntax"> == </span><span class="constant-syntax">IFELSE_BIP</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">second_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">operand2</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">second_child</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">first_child</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">( </span><span class="identifier-syntax">operand2_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_4">&#167;13.4</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP13_4_4" class="paragraph-anchor"></a><b>&#167;13.4.4. </b>It was noted above that the <span class="extract"><span class="extract-syntax">STORE_BIP</span></span> value was being somewhat abused in
the one special case of <span class="extract"><span class="extract-syntax">give O P</span></span> or <span class="extract"><span class="extract-syntax">give O ~P</span></span>. This won't be a statement
at all &mdash; instead we rewrite this as the setting of a property value either
to 1 or 0 respectively. And that makes it an <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> node after all.
</p>

<p class="commentary">It would not have been legal in I6 to use <span class="extract"><span class="extract-syntax">O.P = 1</span></span> as an alternative to <span class="extract"><span class="extract-syntax">give O P</span></span>.
But it is legal to do so in this schema, and that is what our expression node does.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">The special case of giving an attribute</span><span class="named-paragraph-number">13.4.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">A</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">B</span><span class="plain-syntax"> = </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">A</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">OPERATOR_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"."</span><span class="plain-syntax">, </span><span class="constant-syntax">PROPERTYVALUE_BIP</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">B</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">OPERATOR_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"="</span><span class="plain-syntax">, </span><span class="constant-syntax">STORE_BIP</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">T</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::new</span><span class="plain-syntax">();</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="string-syntax">"%d"</span><span class="plain-syntax">, </span><span class="identifier-syntax">dangle_number</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cons</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cons</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP13_4">&#167;13.4</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP14" class="paragraph-anchor"></a><b>&#167;14. The break for statements ramification.</b>This is where we dismantle <span class="extract"><span class="extract-syntax">for (X: Y: Z) ...</span></span> into its constituent parts,
removing the colon and bracket tokens. Thus:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> = </span><span class="constant-syntax">FOR_BIP</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            (</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">X</span>
<span class="plain-syntax">            :</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Y</span>
<span class="plain-syntax">            :</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Z</span>
<span class="plain-syntax">            )</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            ...</span>
</pre>
<p class="commentary">should become
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax"> = </span><span class="constant-syntax">FOR_BIP</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">X</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Y</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">Z</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            ...</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::break_for_statements</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">Ramification::break_for_statements</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">FOR_BIP</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">predicates</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">predicates</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">predicates</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"malformed 'for' loop"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">predicates</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">nearby_token</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">code_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">predicates</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">cw</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</span><span class="plain-syntax">[3], *</span><span class="identifier-syntax">to</span><span class="plain-syntax">[3];</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;3; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) { </span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">] = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">] = </span><span class="constant-syntax">0</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) </span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">End a for loop header clause</span><span class="named-paragraph-number">14.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COLON_ISTT</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">End a for loop header clause</span><span class="named-paragraph-number">14.1</span></a></span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">DCOLON_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">End a for loop header clause</span><span class="named-paragraph-number">14.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">End a for loop header clause</span><span class="named-paragraph-number">14.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">cw</span><span class="plain-syntax"> != </span><span class="constant-syntax">3</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"'for' header with too few clauses"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;3; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EVAL_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">nearby_token</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">code_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">nearby_token</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">eval_isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">];</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">m</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) </span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">m</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">m</span><span class="plain-syntax"> == </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]) </span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">m</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">expr_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]) </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">m</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP14" class="function-link"><span class="function-syntax">Ramification::break_for_statements</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP14_1" class="paragraph-anchor"></a><b>&#167;14.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">End a for loop header clause</span><span class="named-paragraph-number">14.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">cw</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">3</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"'for' header with too many clauses"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] == </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">]) { </span><span class="identifier-syntax">from</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">to</span><span class="plain-syntax">[</span><span class="identifier-syntax">cw</span><span class="plain-syntax">] = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">cw</span><span class="plain-syntax">++;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP14">&#167;14</a> (four times).</li></ul>
<p class="commentary firstcommentary"><a id="SP15" class="paragraph-anchor"></a><b>&#167;15. The add missing bodies ramification.</b>You do this at your own peril, but it is legal in Inform 6 to write, say,
<span class="extract"><span class="extract-syntax">if (...) { ; }</span></span> or <span class="extract"><span class="extract-syntax">while (...) ;</span></span>. In our schema, those statement nodes will
have one fewer child node, because there will be nothing where the final child
node ought to be. We add an empty code node if so, and this saves the schema
from failing its lint test.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::add_missing_bodies</span><button class="popup" onclick="togglePopup('usagePopup14')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup14">Usage of <span class="code-font"><span class="function-syntax">Ramification::add_missing_bodies</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">IF_BIP</span><span class="plain-syntax">)) </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">IFELSE_BIP</span><span class="plain-syntax">)) </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">3</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">FOR_BIP</span><span class="plain-syntax">)) </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">4</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHILE_BIP</span><span class="plain-syntax">)) </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">OBJECTLOOP_BIP</span><span class="plain-syntax">)) </span><span class="identifier-syntax">req</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">req</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">actual</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ch</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">; </span><span class="identifier-syntax">ch</span><span class="plain-syntax">; </span><span class="identifier-syntax">ch</span><span class="plain-syntax">=</span><span class="identifier-syntax">ch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) </span><span class="identifier-syntax">actual</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">actual</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">req</span><span class="plain-syntax">-1) || (</span><span class="identifier-syntax">actual</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">req</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"malformed statement"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">actual</span><span class="plain-syntax"> == </span><span class="identifier-syntax">req</span><span class="plain-syntax">-1) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">code_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node_near_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">CODE_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ch</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">ch</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">ch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">)) </span><span class="identifier-syntax">ch</span><span class="plain-syntax">=</span><span class="identifier-syntax">ch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">ch</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">;</span>

<span class="plain-syntax">                </span><a href="2-is.html#SP5" class="function-link"><span class="function-syntax">InterSchemas::mark_unclosed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">code_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP15" class="function-link"><span class="function-syntax">Ramification::add_missing_bodies</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP16" class="paragraph-anchor"></a><b>&#167;16. The remove empty expressions ramification.</b>If an <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span> contains no tokens, remove it from the tree. (The
parsing process has a tendency to leave these around, especially at the end of
code blocks. They mean nothing, but it's tidy to remove them.)
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::remove_empties</span><button class="popup" onclick="togglePopup('usagePopup15')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup15">Usage of <span class="code-font"><span class="function-syntax">Ramification::remove_empties</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">) </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">par</span><span class="plain-syntax">) </span><span class="identifier-syntax">par</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_tree</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP16" class="function-link"><span class="function-syntax">Ramification::remove_empties</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP17" class="paragraph-anchor"></a><b>&#167;17. The outer subexpressions ramification.</b>If an expression looks like <span class="extract"><span class="extract-syntax">( ... )</span></span>, but not <span class="extract"><span class="extract-syntax">( ... ) ... ( ... )</span></span> &mdash; in
other words, if the entire expression lies inside a matching pair of round
brackets...
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::outer_subexpressions</span><button class="popup" onclick="togglePopup('usagePopup16')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup16">Usage of <span class="code-font"><span class="function-syntax">Ramification::outer_subexpressions</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a>, <a href="2-rmf.html#SP21">&#167;21</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> ( ; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="identifier-syntax">fails</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">, *</span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">fails</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">fails</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">from</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">to</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">from</span><span class="plain-syntax"> != </span><span class="identifier-syntax">to</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP17_1" class="named-paragraph-link"><span class="named-paragraph">This expression is entirely in a matching pair of round brackets</span><span class="named-paragraph-number">17.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP17" class="function-link"><span class="function-syntax">Ramification::outer_subexpressions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP17_1" class="paragraph-anchor"></a><b>&#167;17.1. </b>...then we move the bracketed content under a new subexpression node, so
that <span class="extract"><span class="extract-syntax">(x+1)</span></span> would now become:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">SUBEXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">x</span>
<span class="plain-syntax">            +</span>
<span class="plain-syntax">            </span><span class="constant-syntax">1</span>
</pre>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">This expression is entirely in a matching pair of round brackets</span><span class="named-paragraph-number">17.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sub_node</span><span class="plain-syntax"> = </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">from</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">sub_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sub_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">=</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">to</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sub_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">SUBEXPRESSION_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">sub_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">sub_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP17">&#167;17</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>&#167;18. The top level commas ramification.</b>Commas are now used in just two different ways: to divide up function arguments,
and as the serial evaluation operator. Because we have already performed the outer
subexpressions ramification, we can tell which meaning applies by seeing if a comma
occurs at the top level or inside of brackets. Thus <span class="extract"><span class="extract-syntax">a, b, c</span></span> must be serial
evaluation &mdash; evaluate <span class="extract"><span class="extract-syntax">a</span></span>, then <span class="extract"><span class="extract-syntax">b</span></span>, then <span class="extract"><span class="extract-syntax">c</span></span> &mdash; whereas <span class="extract"><span class="extract-syntax">a + f(b, c)</span></span> cannot be.
</p>

<p class="commentary">This changes
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">a</span>
<span class="plain-syntax">        ,</span>
<span class="plain-syntax">        (</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">b</span>
<span class="plain-syntax">        ,</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">c</span>
<span class="plain-syntax">        )</span>
</pre>
<p class="commentary">to:
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">a</span>
<span class="plain-syntax">    </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">        (</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">b</span>
<span class="plain-syntax">        ,</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">c</span>
<span class="plain-syntax">        )</span>
</pre>
<p class="commentary">After this stage, then, the only commas left are those used for function arguments.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::top_level_commas</span><button class="popup" onclick="togglePopup('usagePopup17')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup17">Usage of <span class="code-font"><span class="function-syntax">Ramification::top_level_commas</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> ( ; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COMMA_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) { </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">n</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semicolon_terminated</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP18" class="function-link"><span class="function-syntax">Ramification::top_level_commas</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>&#167;19. The multiple case values ramification.</b>In Inform 6, a case in a <span class="extract"><span class="extract-syntax">switch</span></span> can contain multiple values, divided by commas.
So the expression node underneath a case might for example have the tokens <span class="extract"><span class="extract-syntax">1 , 2 , 6</span></span>,
and the top level commas ramification will have made those into serial evaluations.
We correct those to uses of the special <span class="extract"><span class="extract-syntax">ALTERNATIVECASE_BIP</span></span> operator instead.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::multiple_case_values</span><button class="popup" onclick="togglePopup('usagePopup18')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup18">Usage of <span class="code-font"><span class="function-syntax">Ramification::multiple_case_values</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">CASE_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">A</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">B</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">A</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">B</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">B</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">C</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                    </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node_near_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">A</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">C</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">ALTERNATIVECASE_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">C</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">A</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">A</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">C</span><span class="plain-syntax">; </span><span class="identifier-syntax">B</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">C</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">C</span><span class="plain-syntax">; </span><span class="identifier-syntax">C</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">B</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">; </span><span class="identifier-syntax">B</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">C</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP19" class="function-link"><span class="function-syntax">Ramification::multiple_case_values</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>&#167;20. The strip all white space ramification.</b>White space has an important role to play earlier on in the process, but once
our tree structure contains the information it carries, we can discard it.
This simply deletes every token of type <span class="extract"><span class="extract-syntax">WHITE_SPACE_ISTT</span></span>.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::strip_all_white_space</span><button class="popup" onclick="togglePopup('usagePopup19')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup19">Usage of <span class="code-font"><span class="function-syntax">Ramification::strip_all_white_space</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">WHITE_SPACE_ISTT</span><span class="plain-syntax">) { </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">; </span><span class="identifier-syntax">d</span><span class="plain-syntax">++; }</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP20" class="function-link"><span class="function-syntax">Ramification::strip_all_white_space</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP21" class="paragraph-anchor"></a><b>&#167;21. The debracket ramification.</b>It's finally time to remove all round bracket tokens from the schema, and this
means understanding which ones clarify the order of operations, as in <span class="extract"><span class="extract-syntax">a * ( b + c)</span></span>,
and which signal function calls, as in <span class="extract"><span class="extract-syntax">f ( a , b )</span></span>. At each node:
</p>

<ul class="items"><li>&#9679; we use <a href="2-rmf.html#SP17" class="internal">Ramification::outer_subexpressions</a> to dispose of the <span class="extract"><span class="extract-syntax">( ... )</span></span> case;
</li><li>&#9679; then <a href="2-rmf.html#SP22" class="internal">Ramification::op_subexpressions</a> to look for the <span class="extract"><span class="extract-syntax">a * ( b + c)</span></span> case;
</li><li>&#9679; and finally <a href="2-rmf.html#SP24" class="internal">Ramification::place_calls</a> to take care of <span class="extract"><span class="extract-syntax">f ( a , b )</span></span>.
</li></ul>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::debracket</span><button class="popup" onclick="togglePopup('usagePopup20')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup20">Usage of <span class="code-font"><span class="function-syntax">Ramification::debracket</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP17" class="function-link"><span class="function-syntax">Ramification::outer_subexpressions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP22" class="function-link"><span class="function-syntax">Ramification::op_subexpressions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP24" class="function-link"><span class="function-syntax">Ramification::place_calls</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>&#167;22. </b>So, then, operations. We detect these because they have an operator at the
top level. Thus, <span class="extract"><span class="extract-syntax">f(x*y) + 2</span></span> must be an operation because of the top-level <span class="extract"><span class="extract-syntax">+</span></span>.
We split this into a left and right operand: <span class="extract"><span class="extract-syntax">f(x*y)</span></span> and <span class="extract"><span class="extract-syntax">2</span></span> in this example.
Those become the children of an <span class="extract"><span class="extract-syntax">OPERATION_ISNT</span></span> node, which replaces the
original <span class="extract"><span class="extract-syntax">EXPRESSION_ISNT</span></span>.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::op_subexpressions</span><button class="popup" onclick="togglePopup('usagePopup21')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup21">Usage of <span class="code-font"><span class="function-syntax">Ramification::op_subexpressions</span></span>:<br/><a href="2-rmf.html#SP21">&#167;21</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> ( ; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">node_marked</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">final_op_token</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP22_1" class="named-paragraph-link"><span class="named-paragraph">Find the lowest-precedence top level operator, if any</span><span class="named-paragraph-number">22.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">final_op_token</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">), *</span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">final_op_token</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">has_right_operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax"> != </span><span class="identifier-syntax">to</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP22_2" class="named-paragraph-link"><span class="named-paragraph">Make the left operand expression</span><span class="named-paragraph-number">22.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">final_op_token</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP22_3" class="named-paragraph-link"><span class="named-paragraph">Make the right operand expression</span><span class="named-paragraph-number">22.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP22_4" class="named-paragraph-link"><span class="named-paragraph">Work out which operation is implied by the operator</span><span class="named-paragraph-number">22.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP22" class="function-link"><span class="function-syntax">Ramification::op_subexpressions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP22_1" class="paragraph-anchor"></a><b>&#167;22.1. </b>For example, the final operator in <span class="extract"><span class="extract-syntax">1 + 3 * ( x . y )</span></span> is the <span class="extract"><span class="extract-syntax">+</span></span>, in that
this is the operation which will be performed last. It's the one with the
lowest precedence out of the two top-level operators here, the <span class="extract"><span class="extract-syntax">+</span></span> and <span class="extract"><span class="extract-syntax">*</span></span>.
</p>

<p class="commentary"><span class="extract"><span class="extract-syntax">in</span></span> is not a reserved word in Inform 6, though it probably should be. It can
be used as an operator, as in the condition <span class="extract"><span class="extract-syntax">if (x in y) ...</span></span>, but it can also
be a variable name. So we will detect it only when it is used infix, and will
otherwise convert it from an <span class="extract"><span class="extract-syntax">OPERATOR_ISTT</span></span> to an <span class="extract"><span class="extract-syntax">IDENTIFIER_ISTT</span></span>.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Find the lowest-precedence top level operator, if any</span><span class="named-paragraph-number">22.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">f</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::first_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">f</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPERATOR_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">this_operator</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">operation_primitive</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">this_operator</span><span class="plain-syntax"> == </span><span class="constant-syntax">IN_BIP</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                ((</span><span class="identifier-syntax">n</span><span class="plain-syntax"> == </span><span class="identifier-syntax">f</span><span class="plain-syntax">) || (</span><a href="2-is.html#SP16" class="function-link"><span class="function-syntax">InterSchemas::next_dark_token</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">operation_primitive</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP23" class="function-link"><span class="function-syntax">Ramification::prefer_over</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">this_operator</span><span class="plain-syntax">, </span><span class="identifier-syntax">final_operation</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">final_op_token</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> = </span><span class="identifier-syntax">this_operator</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP22">&#167;22</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP23" class="paragraph-anchor"></a><b>&#167;23. </b>Well... so actually we have to be a bit more careful about left vs right
associativity if there are two least-precedence operators both at the top
level, as in the case of <span class="extract"><span class="extract-syntax">x - y + z</span></span> or (horrifically) <span class="extract"><span class="extract-syntax">x = y = z</span></span>.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::prefer_over</span><button class="popup" onclick="togglePopup('usagePopup22')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup22">Usage of <span class="code-font"><span class="function-syntax">Ramification::prefer_over</span></span>:<br/><a href="2-rmf.html#SP22_1">&#167;22.1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">existing</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">existing</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-i6o.html#SP9" class="function-link"><span class="function-syntax">I6Operators::precedence</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">) &lt; </span><a href="2-i6o.html#SP9" class="function-link"><span class="function-syntax">I6Operators::precedence</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">existing</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="2-i6o.html#SP9" class="function-link"><span class="function-syntax">I6Operators::precedence</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">) == </span><a href="2-i6o.html#SP9" class="function-link"><span class="function-syntax">I6Operators::precedence</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">existing</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><a href="2-i6o.html#SP10" class="function-link"><span class="function-syntax">I6Operators::right_associative</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">)) &amp;&amp;</span>
<span class="plain-syntax">        (</span><a href="2-i6o.html#SP7" class="function-link"><span class="function-syntax">I6Operators::arity</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">) == </span><span class="constant-syntax">2</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">        (</span><a href="2-i6o.html#SP7" class="function-link"><span class="function-syntax">I6Operators::arity</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">existing</span><span class="plain-syntax">) == </span><span class="constant-syntax">2</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP22_2" class="paragraph-anchor"></a><b>&#167;22.2. </b>So the basic plan is to turn out example <span class="extract"><span class="extract-syntax">x + y * z</span></span> into
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax"> = </span><span class="constant-syntax">PLUS_BIP</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">x</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">y</span><span class="plain-syntax"> * </span><span class="identifier-syntax">z</span>
</pre>
<p class="commentary">Recursion of the above then turns this into
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="constant-syntax">OPERATION_ISNT</span>
<span class="plain-syntax">        </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax"> = </span><span class="constant-syntax">PLUS_BIP</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">x</span>
<span class="plain-syntax">        </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax"> = </span><span class="constant-syntax">TIMES_BIP</span>
<span class="plain-syntax">            </span><span class="constant-syntax">EXPRESSION_ISNT</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">y</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">z</span>
</pre>
<p class="commentary">Here the final operator is the <span class="extract"><span class="extract-syntax">+</span></span>, and there are both left and right operands.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the left operand expression</span><span class="named-paragraph-number">22.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">from</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">=</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">to</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">left_operand_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP22">&#167;22</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP22_3" class="paragraph-anchor"></a><b>&#167;22.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the right operand expression</span><span class="named-paragraph-number">22.3</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">from</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">right_operand_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">has_right_operand</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP22">&#167;22</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP22_4" class="paragraph-anchor"></a><b>&#167;22.4. </b>It's only now that we can clarify the meaning of <span class="extract"><span class="extract-syntax">++</span></span>, for example, which
is one operation used as a prefix, and another used as a suffix.
</p>

<p class="commentary">Note that Inform 6 does allow labels to be used as a value, but only in <span class="extract"><span class="extract-syntax">jump</span></span>
statements or assembly language. Since labels begin with a <span class="extract"><span class="extract-syntax">.</span></span>, as in <span class="extract"><span class="extract-syntax">.Example</span></span>,
we need to be careful not to misread that as a use of the property-value
operation <span class="extract"><span class="extract-syntax">a.b</span></span>.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Work out which operation is implied by the operator</span><span class="named-paragraph-number">22.4</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="identifier-syntax">final_operation</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> == </span><span class="constant-syntax">MINUS_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">UNARYMINUS_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> == </span><span class="constant-syntax">POSTINCREMENT_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">PREINCREMENT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> == </span><span class="constant-syntax">POSTDECREMENT_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">PREDECREMENT_BIP</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">final_operation</span><span class="plain-syntax"> == </span><span class="constant-syntax">PROPERTYVALUE_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">LABEL_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">a</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">has_left_operand</span><span class="plain-syntax">) </span><span class="identifier-syntax">a</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">has_right_operand</span><span class="plain-syntax">) </span><span class="identifier-syntax">a</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">a</span><span class="plain-syntax"> != </span><a href="2-i6o.html#SP7" class="function-link"><span class="function-syntax">I6Operators::arity</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">, </span><span class="string-syntax">"operator '%S' used with %d not %d operand(s)"</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                </span><a href="2-i6o.html#SP5" class="function-link"><span class="function-syntax">I6Operators::I6_notation_for</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax">),</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">a</span><span class="plain-syntax">, </span><a href="2-i6o.html#SP7" class="function-link"><span class="function-syntax">I6Operators::arity</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax">));</span>
<span class="plain-syntax">            </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">msg</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP22">&#167;22</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24. </b>Now for function calls.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::place_calls</span><button class="popup" onclick="togglePopup('usagePopup23')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup23">Usage of <span class="code-font"><span class="function-syntax">Ramification::place_calls</span></span>:<br/><a href="2-rmf.html#SP21">&#167;21</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> ( ; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1" class="named-paragraph-link"><span class="named-paragraph">Maybe the function is itself a bracketed term</span><span class="named-paragraph-number">24.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_2" class="named-paragraph-link"><span class="named-paragraph">Or maybe the function is not bracketed</span><span class="named-paragraph-number">24.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP24" class="function-link"><span class="function-syntax">Ramification::place_calls</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP24_1" class="paragraph-anchor"></a><b>&#167;24.1. </b>This is to catch the super-annoying possibility <span class="extract"><span class="extract-syntax">(array-&gt;2)(7)</span></span>, where an
array lookup is performed to find the address of the function to call.
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Maybe the function is itself a bracketed term</span><span class="named-paragraph-number">24.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">term_count</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">tops</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">opener</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, *</span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) { </span><span class="identifier-syntax">opener</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">term_count</span><span class="plain-syntax">++; }</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">tops</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">term_count</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">tops</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">opener</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">closer</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Call brackets found</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_2" class="paragraph-anchor"></a><b>&#167;24.2. </b>But much more usually...
</p>

<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Or maybe the function is not bracketed</span><span class="named-paragraph-number">24.2</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">opener</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, *</span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">pre_count</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">pre_bracings</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">post_count</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">veto</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">opener</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">opener</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">veto</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">closer</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) </span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> != </span><span class="constant-syntax">INLINE_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">opener</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">pre_count</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">opener</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">closer</span><span class="plain-syntax">)) </span><span class="identifier-syntax">post_count</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">opener</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">pre_bracings</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (((</span><span class="identifier-syntax">pre_count</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) || ((</span><span class="identifier-syntax">pre_count</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">pre_bracings</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">))) &amp;&amp;</span>
<span class="plain-syntax">        (</span><span class="identifier-syntax">post_count</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">opener</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">closer</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">veto</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Call brackets found</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_1_1" class="paragraph-anchor"></a><b>&#167;24.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Call brackets found</span><span class="named-paragraph-number">24.1.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">, *</span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">opener</span><span class="plain-syntax">, *</span><span class="identifier-syntax">resume</span><span class="plain-syntax"> = </span><span class="identifier-syntax">opener</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1_1_1" class="named-paragraph-link"><span class="named-paragraph">Relegate node</span><span class="named-paragraph-number">24.1.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">resume</span><span class="plain-syntax">; </span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax"> != </span><span class="identifier-syntax">closer</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPEN_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">++;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CLOSE_ROUND_ISTT</span><span class="plain-syntax">) </span><span class="identifier-syntax">bl</span><span class="plain-syntax">--;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">bl</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">COMMA_ISTT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="identifier-syntax">resume</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1_1_1" class="named-paragraph-link"><span class="named-paragraph">Relegate node</span><span class="named-paragraph-number">24.1.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">resume</span><span class="plain-syntax">; </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">closer</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="named-paragraph-container code-font"><a href="2-rmf.html#SP24_1_1_1" class="named-paragraph-link"><span class="named-paragraph">Relegate node</span><span class="named-paragraph-number">24.1.1.1</span></a></span><span class="plain-syntax">;</span>

<span class="plain-syntax">    </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">CALL_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP24_1">&#167;24.1</a> and <a href="2-rmf.html#SP24_2">&#167;24.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_1_1_1" class="paragraph-anchor"></a><b>&#167;24.1.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Relegate node</span><span class="named-paragraph-number">24.1.1.1</span></span><span class="comment-syntax"> =</span>
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">from</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">to</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">from</span><span class="plain-syntax"> != </span><span class="identifier-syntax">to</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">            </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">from</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">; </span><span class="identifier-syntax">l</span><span class="plain-syntax">=</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">to</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                </span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        </span><a href="2-is.html#SP15" class="function-link"><span class="function-syntax">InterSchemas::changed_tokens_on</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">xisn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">xisn</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">xisn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">)) </span><span class="identifier-syntax">xisn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">xisn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">xisn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="identifier-syntax">new_isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rmf.html#SP24_1_1">&#167;24.1.1</a> (three times).</li></ul>
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25. The implied return values ramification.</b>A bare <span class="extract"><span class="extract-syntax">return;</span></span> statement in Inform 6 means "return true", i.e., the numerical value 1.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::implied_return_values</span><button class="popup" onclick="togglePopup('usagePopup24')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup24">Usage of <span class="code-font"><span class="function-syntax">Ramification::implied_return_values</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">RETURN_BIP</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">one</span><span class="plain-syntax"> =</span>
<span class="plain-syntax">                </span><a href="2-is.html#SP4" class="function-link"><span class="function-syntax">InterSchemas::new_node_near_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_schema</span><span class="plain-syntax">, </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">one</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax"> = </span><a href="2-is.html#SP10" class="function-link"><span class="function-syntax">InterSchemas::new_token</span></a><span class="plain-syntax">(</span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">, -1, </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">one</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">one</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">one</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">one</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP25" class="function-link"><span class="function-syntax">Ramification::implied_return_values</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26. The message calls ramification.</b>Here we look for the configuration <span class="extract"><span class="extract-syntax">x.y(z)</span></span>, which is a message call &mdash; i.e. a
function call to <span class="extract"><span class="extract-syntax">x.y</span></span>, of a special kind &mdash; rather than a lookup of the property
<span class="extract"><span class="extract-syntax">y(z)</span></span> on the object <span class="extract"><span class="extract-syntax">x</span></span>. We clarify using <span class="extract"><span class="extract-syntax">MESSAGE_ISNT.
</span></span></p>

<p class="commentary">There is also the oddball syntax <span class="extract"><span class="extract-syntax">f.call(y)</span></span>, which performs a function call too.
This is almost useless, but we pick it up anyway.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::message_calls</span><button class="popup" onclick="togglePopup('usagePopup25')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup25">Usage of <span class="code-font"><span class="function-syntax">Ramification::message_calls</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">PROPERTYVALUE_BIP</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">            (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">CALL_ISNT</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">obj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">message</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">args</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">MESSAGE_ISNT</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="identifier-syntax">obj</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">message</span><span class="plain-syntax">; </span><span class="identifier-syntax">message</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">message</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">args</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">message</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">message</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">n</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">n</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"call"</span><span class="plain-syntax">))) {</span>
<span class="plain-syntax">                    </span><span class="identifier-syntax">obj</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">args</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> = </span><span class="constant-syntax">CALLMESSAGE_ISNT</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">args</span><span class="plain-syntax">) { </span><span class="identifier-syntax">args</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parent_node</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">args</span><span class="plain-syntax"> = </span><span class="identifier-syntax">args</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">; }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-rmf.html#SP26" class="function-link"><span class="function-syntax">Ramification::message_calls</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP27" class="paragraph-anchor"></a><b>&#167;27. The sanity check ramification.</b>This does nothing except to catch some errors more politely than allowing them
to cause trouble later. If no error is thrown, the schema is unchanged.
</p>

<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::sanity_check</span><button class="popup" onclick="togglePopup('usagePopup26')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup26">Usage of <span class="code-font"><span class="function-syntax">Ramification::sanity_check</span></span>:<br/><a href="2-rmf.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">; </span><span class="identifier-syntax">isn</span><span class="plain-syntax">=</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">asm</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OPCODE_ISTT:</span><span class="plain-syntax">       </span><span class="identifier-syntax">asm</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RAW_ISTT:</span><span class="plain-syntax">          </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"malformed expression"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OPEN_BRACE_ISTT:</span><span class="plain-syntax">   </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected '{'"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CLOSE_BRACE_ISTT:</span><span class="plain-syntax">  </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected '}'"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OPEN_ROUND_ISTT:</span><span class="plain-syntax">   </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected '('"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CLOSE_ROUND_ISTT:</span><span class="plain-syntax">  </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected ')'"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">COMMA_ISTT:</span><span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected ','"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DIVIDER_ISTT:</span><span class="plain-syntax">      </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"malformed expression"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RESERVED_ISTT:</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">, </span><span class="string-syntax">"unexpected use of reserved word '%S'"</span><span class="plain-syntax">, </span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">msg</span><span class="plain-syntax">);</span>
<span class="plain-syntax">                        </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">msg</span><span class="plain-syntax">)</span>
<span class="plain-syntax">                        </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    }</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">COLON_ISTT:</span><span class="plain-syntax">        </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected ':'"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DCOLON_ISTT:</span><span class="plain-syntax">       </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">,</span>
<span class="plain-syntax">                                                </span><span class="identifier-syntax">I</span><span class="string-syntax">"the Inform 6 '::' operator is unsupported"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                    </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">OPERATOR_ISTT:</span><span class="plain-syntax">     </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"unexpected operator"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax">                }</span>
<span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                    (</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">asm</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                    </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"two consecutive numbers"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            }</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"malformed expression"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">) </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"syntax error"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">STATEMENT_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">CASE_BIP</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                </span><a href="2-rmf.html#SP27" class="function-link"><span class="function-syntax">Ramification::check_for_to</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">OPERATION_ISNT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">ALTERNATIVECASE_BIP</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                </span><a href="2-rmf.html#SP27" class="function-link"><span class="function-syntax">Ramification::check_for_to</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax">                (</span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">isn_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">EXPRESSION_ISNT</span><span class="plain-syntax">))</span>
<span class="plain-syntax">                </span><a href="2-rmf.html#SP27" class="function-link"><span class="function-syntax">Ramification::check_for_to</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">        }</span>
<span class="plain-syntax">        </span><a href="2-rmf.html#SP27" class="function-link"><span class="function-syntax">Ramification::sanity_check</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">);</span>
<span class="plain-syntax">    }</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Ramification::check_for_to</span><span class="plain-syntax">(</span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">par</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_schema_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">isn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">inter_schema_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">isn</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">; </span><span class="identifier-syntax">t</span><span class="plain-syntax">=</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)</span>
<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ist_type</span><span class="plain-syntax"> == </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">t</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">material</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"to"</span><span class="plain-syntax">)))</span>
<span class="plain-syntax">            </span><a href="2-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">isn</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"'to' ranges are unsupported in switch cases"</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
<nav role="progress"><div class="progresscontainer">
    <ul class="progressbar"><li class="progressprev"><a href="2-tkn.html">&#10094;</a></li><li class="progresschapter"><a href="P-wtmd.html">P</a></li><li class="progresschapter"><a href="1-bm.html">1</a></li><li class="progresscurrentchapter">2</li><li class="progresssection"><a href="2-is.html">is</a></li><li class="progresssection"><a href="2-pis.html">pis</a></li><li class="progresssection"><a href="2-tkn.html">tkn</a></li><li class="progresscurrent">rmf</li><li class="progresssection"><a href="2-i6o.html">i6o</a></li><li class="progresssection"><a href="2-eis.html">eis</a></li><li class="progresssection"><a href="2-if.html">if</a></li><li class="progresssection"><a href="2-i6a.html">i6a</a></li><li class="progresssection"><a href="2-i6se.html">i6se</a></li><li class="progresschapter"><a href="3-prd.html">3</a></li><li class="progressnext"><a href="2-i6o.html">&#10095;</a></li></ul></div>
</nav><!-- End of weave -->

		</main>
	</body>
</html>

